home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / sre_compile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  10.8 KB  |  557 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import _sre
  5. import sys
  6. from sre_constants import *
  7. if _sre.CODESIZE == 2:
  8.     MAXCODE = 65535
  9. else:
  10.     MAXCODE = 0xFFFFFFFFL
  11.  
  12. def _identityfunction(x):
  13.     return x
  14.  
  15.  
  16. def set(seq):
  17.     s = { }
  18.     for elem in seq:
  19.         s[elem] = 1
  20.     
  21.     return s
  22.  
  23. _LITERAL_CODES = set([
  24.     LITERAL,
  25.     NOT_LITERAL])
  26. _REPEATING_CODES = set([
  27.     REPEAT,
  28.     MIN_REPEAT,
  29.     MAX_REPEAT])
  30. _SUCCESS_CODES = set([
  31.     SUCCESS,
  32.     FAILURE])
  33. _ASSERT_CODES = set([
  34.     ASSERT,
  35.     ASSERT_NOT])
  36.  
  37. def _compile(code, pattern, flags):
  38.     emit = code.append
  39.     _len = len
  40.     LITERAL_CODES = _LITERAL_CODES
  41.     REPEATING_CODES = _REPEATING_CODES
  42.     SUCCESS_CODES = _SUCCESS_CODES
  43.     ASSERT_CODES = _ASSERT_CODES
  44.     for op, av in pattern:
  45.         if op in LITERAL_CODES:
  46.             if flags & SRE_FLAG_IGNORECASE:
  47.                 emit(OPCODES[OP_IGNORE[op]])
  48.                 emit(_sre.getlower(av, flags))
  49.             else:
  50.                 emit(OPCODES[op])
  51.                 emit(av)
  52.         flags & SRE_FLAG_IGNORECASE
  53.         if op is IN:
  54.             if flags & SRE_FLAG_IGNORECASE:
  55.                 emit(OPCODES[OP_IGNORE[op]])
  56.                 
  57.                 def fixup(literal, flags = flags):
  58.                     return _sre.getlower(literal, flags)
  59.  
  60.             else:
  61.                 emit(OPCODES[op])
  62.                 fixup = _identityfunction
  63.             skip = _len(code)
  64.             emit(0)
  65.             _compile_charset(av, flags, code, fixup)
  66.             code[skip] = _len(code) - skip
  67.             continue
  68.         if op is ANY:
  69.             if flags & SRE_FLAG_DOTALL:
  70.                 emit(OPCODES[ANY_ALL])
  71.             else:
  72.                 emit(OPCODES[ANY])
  73.         flags & SRE_FLAG_DOTALL
  74.         if op in REPEATING_CODES:
  75.             if flags & SRE_FLAG_TEMPLATE:
  76.                 raise error, 'internal: unsupported template operator'
  77.                 emit(OPCODES[REPEAT])
  78.                 skip = _len(code)
  79.                 emit(0)
  80.                 emit(av[0])
  81.                 emit(av[1])
  82.                 _compile(code, av[2], flags)
  83.                 emit(OPCODES[SUCCESS])
  84.                 code[skip] = _len(code) - skip
  85.             elif _simple(av) and op is not REPEAT:
  86.                 if op is MAX_REPEAT:
  87.                     emit(OPCODES[REPEAT_ONE])
  88.                 else:
  89.                     emit(OPCODES[MIN_REPEAT_ONE])
  90.                 skip = _len(code)
  91.                 emit(0)
  92.                 emit(av[0])
  93.                 emit(av[1])
  94.                 _compile(code, av[2], flags)
  95.                 emit(OPCODES[SUCCESS])
  96.                 code[skip] = _len(code) - skip
  97.             else:
  98.                 emit(OPCODES[REPEAT])
  99.                 skip = _len(code)
  100.                 emit(0)
  101.                 emit(av[0])
  102.                 emit(av[1])
  103.                 _compile(code, av[2], flags)
  104.                 code[skip] = _len(code) - skip
  105.                 if op is MAX_REPEAT:
  106.                     emit(OPCODES[MAX_UNTIL])
  107.                 else:
  108.                     emit(OPCODES[MIN_UNTIL])
  109.         op is MAX_REPEAT
  110.         if op is SUBPATTERN:
  111.             if av[0]:
  112.                 emit(OPCODES[MARK])
  113.                 emit((av[0] - 1) * 2)
  114.             
  115.             _compile(code, av[1], flags)
  116.             if av[0]:
  117.                 emit(OPCODES[MARK])
  118.                 emit((av[0] - 1) * 2 + 1)
  119.             
  120.         av[0]
  121.         if op in SUCCESS_CODES:
  122.             emit(OPCODES[op])
  123.             continue
  124.         if op in ASSERT_CODES:
  125.             emit(OPCODES[op])
  126.             skip = _len(code)
  127.             emit(0)
  128.             if av[0] >= 0:
  129.                 emit(0)
  130.             else:
  131.                 (lo, hi) = av[1].getwidth()
  132.                 if lo != hi:
  133.                     raise error, 'look-behind requires fixed-width pattern'
  134.                 
  135.                 emit(lo)
  136.             _compile(code, av[1], flags)
  137.             emit(OPCODES[SUCCESS])
  138.             code[skip] = _len(code) - skip
  139.             continue
  140.         if op is CALL:
  141.             emit(OPCODES[op])
  142.             skip = _len(code)
  143.             emit(0)
  144.             _compile(code, av, flags)
  145.             emit(OPCODES[SUCCESS])
  146.             code[skip] = _len(code) - skip
  147.             continue
  148.         if op is AT:
  149.             emit(OPCODES[op])
  150.             if flags & SRE_FLAG_MULTILINE:
  151.                 av = AT_MULTILINE.get(av, av)
  152.             
  153.             if flags & SRE_FLAG_LOCALE:
  154.                 av = AT_LOCALE.get(av, av)
  155.             elif flags & SRE_FLAG_UNICODE:
  156.                 av = AT_UNICODE.get(av, av)
  157.             
  158.             emit(ATCODES[av])
  159.             continue
  160.         if op is BRANCH:
  161.             emit(OPCODES[op])
  162.             tail = []
  163.             tailappend = tail.append
  164.             for av in av[1]:
  165.                 skip = _len(code)
  166.                 emit(0)
  167.                 _compile(code, av, flags)
  168.                 emit(OPCODES[JUMP])
  169.                 tailappend(_len(code))
  170.                 emit(0)
  171.                 code[skip] = _len(code) - skip
  172.             
  173.             emit(0)
  174.             for tail in tail:
  175.                 code[tail] = _len(code) - tail
  176.             
  177.         if op is CATEGORY:
  178.             emit(OPCODES[op])
  179.             if flags & SRE_FLAG_LOCALE:
  180.                 av = CH_LOCALE[av]
  181.             elif flags & SRE_FLAG_UNICODE:
  182.                 av = CH_UNICODE[av]
  183.             
  184.             emit(CHCODES[av])
  185.             continue
  186.         if op is GROUPREF:
  187.             if flags & SRE_FLAG_IGNORECASE:
  188.                 emit(OPCODES[OP_IGNORE[op]])
  189.             else:
  190.                 emit(OPCODES[op])
  191.             emit(av - 1)
  192.             continue
  193.         if op is GROUPREF_EXISTS:
  194.             emit(OPCODES[op])
  195.             emit(av[0] - 1)
  196.             skipyes = _len(code)
  197.             emit(0)
  198.             _compile(code, av[1], flags)
  199.             if av[2]:
  200.                 emit(OPCODES[JUMP])
  201.                 skipno = _len(code)
  202.                 emit(0)
  203.                 code[skipyes] = (_len(code) - skipyes) + 1
  204.                 _compile(code, av[2], flags)
  205.                 code[skipno] = _len(code) - skipno
  206.             else:
  207.                 code[skipyes] = (_len(code) - skipyes) + 1
  208.         av[2]
  209.         raise ValueError, ('unsupported operand type', op)
  210.     
  211.  
  212.  
  213. def _compile_charset(charset, flags, code, fixup = None):
  214.     emit = code.append
  215.     if fixup is None:
  216.         fixup = _identityfunction
  217.     
  218.     for op, av in _optimize_charset(charset, fixup):
  219.         emit(OPCODES[op])
  220.         if op is NEGATE:
  221.             continue
  222.         if op is LITERAL:
  223.             emit(fixup(av))
  224.             continue
  225.         if op is RANGE:
  226.             emit(fixup(av[0]))
  227.             emit(fixup(av[1]))
  228.             continue
  229.         if op is CHARSET:
  230.             code.extend(av)
  231.             continue
  232.         if op is BIGCHARSET:
  233.             code.extend(av)
  234.             continue
  235.         if op is CATEGORY:
  236.             if flags & SRE_FLAG_LOCALE:
  237.                 emit(CHCODES[CH_LOCALE[av]])
  238.             elif flags & SRE_FLAG_UNICODE:
  239.                 emit(CHCODES[CH_UNICODE[av]])
  240.             else:
  241.                 emit(CHCODES[av])
  242.         flags & SRE_FLAG_LOCALE
  243.         raise error, 'internal: unsupported set operator'
  244.     
  245.     emit(OPCODES[FAILURE])
  246.  
  247.  
  248. def _optimize_charset(charset, fixup):
  249.     out = []
  250.     outappend = out.append
  251.     charmap = [
  252.         0] * 256
  253.     
  254.     try:
  255.         for op, av in charset:
  256.             if op is NEGATE:
  257.                 outappend((op, av))
  258.                 continue
  259.             if op is LITERAL:
  260.                 charmap[fixup(av)] = 1
  261.                 continue
  262.             if op is RANGE:
  263.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  264.                     charmap[i] = 1
  265.                 
  266.             if op is CATEGORY:
  267.                 return charset
  268.                 continue
  269.     except IndexError:
  270.         return _optimize_unicode(charset, fixup)
  271.  
  272.     i = p = n = 0
  273.     runs = []
  274.     runsappend = runs.append
  275.     for c in charmap:
  276.         if c:
  277.             if n == 0:
  278.                 p = i
  279.             
  280.             n = n + 1
  281.         elif n:
  282.             runsappend((p, n))
  283.             n = 0
  284.         
  285.         i = i + 1
  286.     
  287.     if n:
  288.         runsappend((p, n))
  289.     
  290.     if len(runs) <= 2:
  291.         for p, n in runs:
  292.             if n == 1:
  293.                 outappend((LITERAL, p))
  294.                 continue
  295.             outappend((RANGE, (p, p + n - 1)))
  296.         
  297.         if len(out) < len(charset):
  298.             return out
  299.         
  300.     else:
  301.         data = _mk_bitmap(charmap)
  302.         outappend((CHARSET, data))
  303.         return out
  304.     return charset
  305.  
  306.  
  307. def _mk_bitmap(bits):
  308.     data = []
  309.     dataappend = data.append
  310.     if _sre.CODESIZE == 2:
  311.         start = (1, 0)
  312.     else:
  313.         start = (0x1L, 0x0L)
  314.     (m, v) = start
  315.     for c in bits:
  316.         if c:
  317.             v = v + m
  318.         
  319.         m = m + m
  320.         if m > MAXCODE:
  321.             dataappend(v)
  322.             (m, v) = start
  323.             continue
  324.     
  325.     return data
  326.  
  327.  
  328. def _optimize_unicode(charset, fixup):
  329.     
  330.     try:
  331.         import array
  332.     except ImportError:
  333.         return charset
  334.  
  335.     charmap = [
  336.         0] * 65536
  337.     negate = 0
  338.     
  339.     try:
  340.         for op, av in charset:
  341.             if op is NEGATE:
  342.                 negate = 1
  343.                 continue
  344.             if op is LITERAL:
  345.                 charmap[fixup(av)] = 1
  346.                 continue
  347.             if op is RANGE:
  348.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  349.                     charmap[i] = 1
  350.                 
  351.             if op is CATEGORY:
  352.                 return charset
  353.                 continue
  354.     except IndexError:
  355.         return charset
  356.  
  357.     if negate:
  358.         if sys.maxunicode != 65535:
  359.             return charset
  360.         
  361.         for i in xrange(65536):
  362.             charmap[i] = not charmap[i]
  363.         
  364.     
  365.     comps = { }
  366.     mapping = [
  367.         0] * 256
  368.     block = 0
  369.     data = []
  370.     for i in xrange(256):
  371.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  372.         new = comps.setdefault(chunk, block)
  373.         mapping[i] = new
  374.         if new == block:
  375.             block = block + 1
  376.             data = data + _mk_bitmap(chunk)
  377.             continue
  378.     
  379.     header = [
  380.         block]
  381.     if _sre.CODESIZE == 2:
  382.         code = 'H'
  383.     else:
  384.         code = 'I'
  385.     mapping = array.array('b', mapping).tostring()
  386.     mapping = array.array(code, mapping)
  387.     header = header + mapping.tolist()
  388.     data[0:0] = header
  389.     return [
  390.         (BIGCHARSET, data)]
  391.  
  392.  
  393. def _simple(av):
  394.     (lo, hi) = av[2].getwidth()
  395.     if lo == 0 and hi == MAXREPEAT:
  396.         raise error, 'nothing to repeat'
  397.     
  398.     if hi == hi:
  399.         pass
  400.     elif hi == 1:
  401.         pass
  402.     return av[2][0][0] != SUBPATTERN
  403.  
  404.  
  405. def _compile_info(code, pattern, flags):
  406.     (lo, hi) = pattern.getwidth()
  407.     if lo == 0:
  408.         return None
  409.     
  410.     prefix = []
  411.     prefixappend = prefix.append
  412.     prefix_skip = 0
  413.     charset = []
  414.     charsetappend = charset.append
  415.     if not flags & SRE_FLAG_IGNORECASE:
  416.         for op, av in pattern.data:
  417.             if op is LITERAL:
  418.                 if len(prefix) == prefix_skip:
  419.                     prefix_skip = prefix_skip + 1
  420.                 
  421.                 prefixappend(av)
  422.                 continue
  423.             if op is SUBPATTERN and len(av[1]) == 1:
  424.                 (op, av) = av[1][0]
  425.                 if op is LITERAL:
  426.                     prefixappend(av)
  427.                 else:
  428.                     break
  429.             op is LITERAL
  430.         
  431.         if not prefix and pattern.data:
  432.             (op, av) = pattern.data[0]
  433.             if op is SUBPATTERN and av[1]:
  434.                 (op, av) = av[1][0]
  435.                 if op is LITERAL:
  436.                     charsetappend((op, av))
  437.                 elif op is BRANCH:
  438.                     c = []
  439.                     cappend = c.append
  440.                     for p in av[1]:
  441.                         if not p:
  442.                             break
  443.                         
  444.                         (op, av) = p[0]
  445.                         if op is LITERAL:
  446.                             cappend((op, av))
  447.                             continue
  448.                     else:
  449.                         charset = c
  450.                 
  451.             elif op is BRANCH:
  452.                 c = []
  453.                 cappend = c.append
  454.                 for p in av[1]:
  455.                     if not p:
  456.                         break
  457.                     
  458.                     (op, av) = p[0]
  459.                     if op is LITERAL:
  460.                         cappend((op, av))
  461.                         continue
  462.                 else:
  463.                     charset = c
  464.             elif op is IN:
  465.                 charset = av
  466.             
  467.         
  468.     
  469.     emit = code.append
  470.     emit(OPCODES[INFO])
  471.     skip = len(code)
  472.     emit(0)
  473.     mask = 0
  474.     if prefix:
  475.         mask = SRE_INFO_PREFIX
  476.         if prefix_skip == prefix_skip:
  477.             pass
  478.         elif prefix_skip == len(pattern.data):
  479.             mask = mask + SRE_INFO_LITERAL
  480.         
  481.     elif charset:
  482.         mask = mask + SRE_INFO_CHARSET
  483.     
  484.     emit(mask)
  485.     if lo < MAXCODE:
  486.         emit(lo)
  487.     else:
  488.         emit(MAXCODE)
  489.         prefix = prefix[:MAXCODE]
  490.     if hi < MAXCODE:
  491.         emit(hi)
  492.     else:
  493.         emit(0)
  494.     if prefix:
  495.         emit(len(prefix))
  496.         emit(prefix_skip)
  497.         code.extend(prefix)
  498.         table = [
  499.             -1] + [
  500.             0] * len(prefix)
  501.         for i in xrange(len(prefix)):
  502.             table[i + 1] = table[i] + 1
  503.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  504.                 table[i + 1] = table[table[i + 1] - 1] + 1
  505.         
  506.         code.extend(table[1:])
  507.     elif charset:
  508.         _compile_charset(charset, flags, code)
  509.     
  510.     code[skip] = len(code) - skip
  511.  
  512.  
  513. try:
  514.     unicode
  515. except NameError:
  516.     STRING_TYPES = (type(''),)
  517.  
  518. STRING_TYPES = (type(''), type(unicode('')))
  519.  
  520. def isstring(obj):
  521.     for tp in STRING_TYPES:
  522.         if isinstance(obj, tp):
  523.             return 1
  524.             continue
  525.     
  526.     return 0
  527.  
  528.  
  529. def _code(p, flags):
  530.     flags = p.pattern.flags | flags
  531.     code = []
  532.     _compile_info(code, p, flags)
  533.     _compile(code, p.data, flags)
  534.     code.append(OPCODES[SUCCESS])
  535.     return code
  536.  
  537.  
  538. def compile(p, flags = 0):
  539.     if isstring(p):
  540.         import sre_parse
  541.         pattern = p
  542.         p = sre_parse.parse(p, flags)
  543.     else:
  544.         pattern = None
  545.     code = _code(p, flags)
  546.     if p.pattern.groups > 100:
  547.         raise AssertionError('sorry, but this version only supports 100 named groups')
  548.     
  549.     groupindex = p.pattern.groupdict
  550.     indexgroup = [
  551.         None] * p.pattern.groups
  552.     for k, i in groupindex.items():
  553.         indexgroup[i] = k
  554.     
  555.     return _sre.compile(pattern, flags | p.pattern.flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  556.  
  557.